home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / system / filesyst / ncpfs / mars_dos.000 / mars_dos / netpc / tools.c < prev   
Encoding:
C/C++ Source or Header  |  1996-05-21  |  6.9 KB  |  297 lines
  1. /* tools.c: 12-Jan-96 */
  2. #include "net.h"
  3.  
  4. /****************************************************************
  5.  * (C)opyright (C) 1993,1996  Martin Stover, Marburg, Germany   *
  6.  ****************************************************************/
  7.  
  8. int key_pressed(void)
  9. {
  10.   REGS regsin, regsout;
  11.   regsin.h.ah = 0x01; /* read key-press */
  12.   int86(0x16, ®sin, ®sout);
  13.   return((regsout.x.flags & 0x40) ? 0 : 1); /* zeroflag != 0 */
  14. }
  15.  
  16. void clear_kb(void)
  17. {
  18.   REGS regsin, regsout;
  19.   while (key_pressed()) {    /* zeroflag != 0 */
  20.     regsin.h.ah = 0x00;      /* read key-press */
  21.     int86(0x16, ®sin, ®sout);
  22.   }
  23. }
  24.  
  25. int ask_user(char *p, ...)
  26. {
  27.    int key;
  28.    int flag = 0;
  29.    va_list argptr;
  30.    va_start(argptr, p);
  31.    vfprintf(stderr, p, argptr);
  32.    va_end(argptr);
  33.    fprintf(stderr, "\n Please answer: Y)es or N)o!");
  34.    while (1) {
  35.      key = getch();
  36.      if (key == 'J' || key == 'j' || key== 'y' || key == 'Y') {
  37.        fprintf(stderr, "Y\n\n");
  38.        flag = 1;
  39.        break;
  40.      }
  41.      if (key == 'N' || key == 'n') {
  42.        fprintf(stderr, "N\n\n");
  43.        flag = 0;
  44.        break;
  45.      }
  46.    }
  47.    clear_kb();
  48.    return(flag);
  49. }
  50.  
  51. char *xmalloc(uint size)
  52. {
  53.   char *p = (size) ? (char *)malloc(size) : (char*)NULL;
  54.   if (p == (char *)NULL && size){
  55.     fprintf(stderr, "not enough core, need %d Bytes\n", size);
  56.     exit(1);
  57.   }
  58.   return(p);
  59. }
  60.  
  61. char *xcmalloc(uint size)
  62. {
  63.   char *p = xmalloc(size);
  64.   if (size) memset(p, 0, size);
  65.   return(p);
  66. }
  67.  
  68. void x_x_xfree(char **p)
  69. {
  70.   if (*p != (char *)NULL){
  71.     free(*p);
  72.     *p = (char*)NULL;
  73.   }
  74. }
  75.  
  76. int strmaxcpy(char *dest, char *source, int len)
  77. /* copied max. len chars + '\0' Byte */
  78. {
  79.   int slen = (source != (char *)NULL) ? min(len, strlen(source)) : 0;
  80.   if (dest == (char *)NULL) return(0);
  81.   if (slen) memcpy(dest, source, slen);
  82.   dest[slen] = '\0';
  83.   return(slen);
  84. }
  85.  
  86. char *xadd_char(char *s, int c, int maxlen)
  87. {
  88.   if (s && maxlen) {
  89.     int namlen = strlen(s);
  90.     if (maxlen > -1 && namlen >= maxlen) namlen=maxlen-1;
  91.     s[namlen++] = c;
  92.     s[namlen]   = '\0';
  93.   }
  94.   return(s);
  95. }
  96.  
  97. static uint8 down_char(uint8 ch)
  98. {
  99.   if (ch > 64 && ch < 91) return(ch + 32);
  100.   switch(ch){
  101.     case 142:  ch =  132; break;
  102.     case 153:  ch =  148; break;
  103.     case 154:  ch =  129; break;
  104.     default :break;
  105.   }
  106.   return(ch);
  107. }
  108.  
  109. static uint8 up_char(uint8 ch)
  110. {
  111.   if (ch > 96 && ch < 123) return(ch - 32);
  112.   switch(ch) {
  113.     case 132:  ch =  142; break;
  114.     case 148:  ch =  153; break;
  115.     case 129:  ch =  154; break;
  116.     default :  break;
  117.   }
  118.   return(ch);
  119. }
  120.  
  121. uint8 *upstr(uint8 *s)
  122. {
  123.   if (!s) return((uint8*)NULL);
  124.   for (;*s;s++) *s=up_char(*s);
  125.   return(s);
  126. }
  127.  
  128. void deb(uint8 *s)
  129. {
  130.   if (!s || !*s) return;
  131.   else {
  132.     uint8 *p = s + strlen(s);
  133.     while (p > s && (*--p==32 || *p==9));;
  134.     if (*p==32 || *p==9) *p='\0';
  135.     else *(p+1) = '\0';
  136.   }
  137. }
  138.  
  139. void leb(uint8 *s)
  140. {
  141.   if (!s || !*s || (*s != 32 && *s != 9)) return;
  142.   else {
  143.     uint8 *p = s;
  144.     for (;*p && *p!=32 && *p!=9;p++);;
  145.     strcpy(s, p);
  146.   }
  147. }
  148.  
  149. void korrpath(char *s)
  150. {
  151.   if (!s) return;
  152.   for (;*s;s++) {
  153.     if (*s=='\\') *s='/';
  154.     else *s=down_char(*s);
  155.   }
  156. }
  157.  
  158. void get_path_fn(char *s, char *p, char *fn)
  159. {
  160.   int j= strlen(s);
  161.   if (p  != (char *)NULL)  p[0]  = 0;
  162.   if (fn != (char*) NULL)  fn[0] = 0;
  163.   if (!j) return;
  164.   if (s[0] == '.' && (s[1] == 0 || (s[1] == '.' && s[2] == 0) ) ) {
  165.     if (p != (char *)NULL) {
  166.       strcpy(p, s);
  167.       strcat(p, "/");
  168.     }
  169.     if (fn != (char *)NULL) fn[0] = 0;
  170.     return;
  171.   }
  172.   while (j--){
  173.     if ((s[j] == '/') || (s[j] == ':') ) {
  174.       if (fn != (char *)NULL) strcpy(fn, s+j+1);
  175.       if (p != (char *)NULL) {
  176.         strncpy(p, s, j+1);
  177.         p[j+1] = 0;
  178.       }
  179.       return;
  180.     }
  181.   }
  182.   if (fn != (char *)NULL) strcpy(fn, s);  /* no path */
  183. }
  184.  
  185.  
  186. typedef struct {
  187.   uint16  adr1;
  188.   uint16  adr2;
  189.   char    reserve[6];
  190.   uint32  ladrs[3];
  191.   uint16  father_psp_seg;
  192.   char    handles[20];
  193.   uint16  environ_seg;
  194. } PROG_PSP;
  195.  
  196. typedef struct {
  197.   uint8  kennung;
  198.   uint16 prozess_seg;
  199.   uint16 blocks;
  200. } SPEICH_BLOCK;
  201.  
  202. static char *getglobenvironment(uint16 *maxsize, uint16 *aktsize)
  203. {
  204.   static uint16 globmaxenvsize=0;
  205.   static char  *globenviron=NULL;
  206.   if (globenviron == (char *) NULL) {
  207.     PROG_PSP *mypsp     = MK_FP(_psp, 0);
  208.     PROG_PSP *fatherpsp = MK_FP(mypsp->father_psp_seg,   0);
  209.     SPEICH_BLOCK *spb   = MK_FP(fatherpsp->environ_seg-1, 0);
  210.     globenviron = (char *)MK_FP(fatherpsp->environ_seg, 0);
  211.     globmaxenvsize      = spb->blocks * 16;
  212.   }
  213.   if (globmaxenvsize){
  214.     char *search    = globenviron;
  215.     char *maxsearch = search+globmaxenvsize;
  216.     while (*search && search < maxsearch) {
  217.       int slen=strlen(search);
  218.       search+=(slen+1);
  219.     }
  220.     *aktsize = max(2, (uint16)(search+1 - globenviron));
  221.   } else *aktsize=0;
  222.   *maxsize = globmaxenvsize;
  223.   /*
  224.   printf("globenv=%p maxsize=%d, aktsize=%d\n", globenviron, globmaxenvsize, *aktsize);
  225.   */
  226.   return(globenviron);
  227. }
  228.  
  229. char *getglobenv(char *option)
  230. {
  231.   uint16 maxenvsize;
  232.   uint16 aktenvsize;
  233.   char   *search = getglobenvironment(&maxenvsize, &aktenvsize);
  234.   int length = (option == NULL) ? 0 : strlen(option);
  235.   if (aktenvsize && length){
  236.     char *maxsearch=search+aktenvsize;
  237.     while (*search && search < maxsearch) {
  238.       int slen=strlen(search);
  239.       if (slen > length && (*(search + length) == '=')
  240.          && (strncmp(search, option, length) == 0)) {
  241.         /*
  242.         printf("GET GLOB %s=%s\n", option, search+length+1);
  243.         */
  244.         return(search + length + 1);
  245.       }
  246.       search+=(slen+1);
  247.     }
  248.   }
  249.   return(NULL);
  250. }
  251.  
  252. int putglobenv(char *option)
  253. {
  254.   uint16 maxenvsize;
  255.   uint16 aktenvsize;
  256.   char   *search   = getglobenvironment(&maxenvsize, &aktenvsize);
  257.   int    optionlen = (option == NULL) ? 0 : strlen(option);
  258.   /*
  259.   printf("PUT GLOB option=%s\n", option);
  260.   */
  261.   if (optionlen && maxenvsize){
  262.     int    length;
  263.     char   *equal;
  264.     for (equal = option; *equal && *equal != '='; equal++);;
  265.     length = (int) (equal - option);
  266.     if (length > 0 && *equal == '='){
  267.       char *maxsearch=search+aktenvsize;
  268.       while (*search && search < maxsearch) {
  269.         int slen    = strlen(search);
  270.         char *nextp = search+slen+1;
  271.         if (slen > length && (*(search + length) == '=')
  272.           && (strncmp(search, option, length) == 0)) { /* gefunden */
  273.           int diffsize   = optionlen-slen;
  274.           if (diffsize){
  275.             int movesize = (int)(maxsearch  - nextp);
  276.             if (diffsize > (int)(maxenvsize - aktenvsize))
  277.                return(-1); /* Kein Platz mehr */
  278.             if (!*(equal+1)) diffsize -= (length+2);
  279.             xmemmove(nextp+diffsize, nextp, movesize);
  280.           }
  281.           if (*(equal+1)) strcpy(search, option);
  282.           return(0);
  283.         }
  284.         search=nextp;
  285.       }
  286.       /* nicht gefunden , nun eintragen, falls möglich */
  287.       if (*(equal+1) && optionlen < maxenvsize - aktenvsize) {
  288.         strcpy(search, option);
  289.         *(search+optionlen+1) = '\0'; /* letzter Eintrag '\0' nicht vergessen */
  290.         return(0);
  291.       } else return(-1);
  292.     }
  293.   }
  294.   return(-1);
  295. }
  296.  
  297.